Large software systems, such as system of systems and web based systems, are often developed using multiple computer programming languages. These systems also largely use a plurality of commercially off the shelf (COTS) components developed using multiple programming languages. Hence, such practice makes it difficult for software developers to comprehend and identify the dependencies between subsystems across language boundaries, estimate impact of code-changes and bug localization from a global perspective.
Cross language dependencies in software system is defined as a set of imperceptible interactions among all components such as source-files, configuration files, binary files, external packages, etc. In such a system, dependencies across the programming languages are common firstly because of several modules programmed in one programming language interact with modules programmed in another programming language. Secondly, the Legacy systems and COTS based systems are typically large and heterogeneous, with many scripts and glue code for integrating the old and newer modules and similarly application and COTS components. Thirdly, many systems are architected in a style of “system of systems”, wherein, a number of systems (or sub-systems) co-exist within the larger system. In such architecture, it is common to have each sub-system programmed in different programming languages and interactions between the sub-systems occur in the form of services.
The current techniques are based on dependency graphs between fine grained elements of the software, interpreting connections using class-path levels etc. in such cases another layer of abstraction needs to be formed on top of these software artifacts to extract dependencies, which lead to inefficiencies. Other challenges in extracting dependencies are estimating change propagation, evaluating impact analysis across-programming-language relationships in software systems that are implemented in multiple programming languages. The reason for inefficiency of existing techniques is, focus on dependencies within individual languages, not across multiple languages. The current techniques do not consider all sources of information perspective (impact across source-files in all languages, configuration files, binary files, external packages, etc.). Also, the current methods of visualizing the dependencies between software artifacts are complicated and imperceptible. Typically, in order to relive developers from the laborious task of interpreting large software systems and recommending potential changes in software, program analyzers are used. Program analyzers extract dependencies between modules and recommend potential changes to the software. However, such techniques are less efficient when applied to large software system of systems and systems that are built using multiple programming languages.
In view of forgoing discussion, there is a need for new techniques and tools that extract dependencies and estimate code change impacts across languages. Such information helps developers to interpret, debug and understand multi-language systems easily, quickly and reliably as opposed to manual interpretation.